home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1995 August: Tool Chest / Dev.CD Aug 95 TC / Dev.CD Aug 95 TC.toast / Tool Chest / Interfaces / UniversalInterfaces 2.1B1 / AIncludes / Memory.a < prev    next >
Encoding:
Text File  |  1995-04-18  |  22.6 KB  |  1,284 lines  |  [TEXT/MPS ]
  1. ;
  2. ;    File:        Memory.a
  3. ;
  4. ;    Contains:    Memory Manager Interfaces.
  5. ;
  6. ;    Version:    Technology:    System 7.5
  7. ;                Package:    Universal Interfaces 2.1ß1.1 in “MPW Prerelease” on ETO #17
  8. ;
  9. ;    Copyright:    © 1984-1995 by Apple Computer, Inc.
  10. ;                All rights reserved.
  11. ;
  12. ;    Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13. ;                stack.  Include the file and version information (from above)
  14. ;                in the problem description and send to:
  15. ;                    Internet:    apple.bugs@applelink.apple.com
  16. ;                    AppleLink:    APPLE.BUGS
  17. ;
  18. ;
  19.  
  20.     IF &TYPE('__MEMORY__') = 'UNDEFINED' THEN
  21. __MEMORY__ SET 1
  22.  
  23.  
  24.     IF &TYPE('__TYPES__') = 'UNDEFINED' THEN
  25.     include 'Types.a'
  26.     ENDIF
  27. ;        include 'ConditionalMacros.a'                                ;
  28.  
  29.     IF &TYPE('__MIXEDMODE__') = 'UNDEFINED' THEN
  30.     include 'MixedMode.a'
  31.     ENDIF
  32.  
  33. maxSize                            EQU        $800000                ;Max data block size is 8 megabytes
  34. defaultPhysicalEntryCount        EQU        8
  35. ; values returned from the GetPageState function 
  36. kPageInMemory                    EQU        0
  37. kPageOnDisk                        EQU        1
  38. kNotPaged                        EQU        2
  39.  
  40. ; masks for Zone->heapType field 
  41. k32BitHeap                        EQU        1                    ; valid in all Memory Managers 
  42. kNewStyleHeap                    EQU        2                    ; true if new Heap Manager is present 
  43. kNewDebugHeap                    EQU        4                    ; true if new Heap Manager is running in debug mode on this heap 
  44.  
  45. ; size of a block in bytes 
  46. ; typedef long                 Size
  47. ; typedef struct Zone         Zone, *THz
  48. Zone                     RECORD    0
  49. bkLim                     ds.l   1        ; offset: $0 (0)
  50. purgePtr                 ds.l   1        ; offset: $4 (4)
  51. hFstFree                 ds.l   1        ; offset: $8 (8)
  52. zcbFree                     ds.l   1        ; offset: $C (12)
  53. gzProc                     ds.l   1        ; offset: $10 (16)
  54. moreMast                 ds.w   1        ; offset: $14 (20)
  55. flags                     ds.w   1        ; offset: $16 (22)
  56. cntRel                     ds.w   1        ; offset: $18 (24)
  57. maxRel                     ds.w   1        ; offset: $1A (26)
  58. cntNRel                     ds.w   1        ; offset: $1C (28)
  59. heapType                 ds.b   1        ; offset: $1E (30)
  60. unused                     ds.b   1        ; offset: $1F (31)
  61. cntEmpty                 ds.w   1        ; offset: $20 (32)
  62. cntHandles                 ds.w   1        ; offset: $22 (34)
  63. minCBFree                 ds.l   1        ; offset: $24 (36)
  64. purgeProc                 ds.l   1        ; offset: $28 (40)
  65. sparePtr                 ds.l   1        ; offset: $2C (44)
  66. allocPtr                 ds.l   1        ; offset: $30 (48)
  67. heapData                 ds.w   1        ; offset: $34 (52)
  68. sizeof                     EQU *            ; size:   $36 (54)
  69.                         ENDR
  70.  
  71. MemoryBlock             RECORD    0
  72. address                     ds.l   1        ; offset: $0 (0)
  73. count                     ds.l   1        ; offset: $4 (4)
  74. sizeof                     EQU *            ; size:   $8 (8)
  75.                         ENDR
  76.  
  77. ; typedef struct MemoryBlock  MemoryBlock
  78. LogicalToPhysicalTable     RECORD    0
  79. logical                     ds     MemoryBlock ; offset: $0 (0)
  80. physical                 ds.b   8 * MemoryBlock.sizeof ; offset: $8 (8)
  81. sizeof                     EQU *            ; size:   $48 (72)
  82.                         ENDR
  83.  
  84. ; typedef struct LogicalToPhysicalTable  LogicalToPhysicalTable
  85. ; typedef short             PageState
  86. ; typedef short             StatusRegisterContents
  87. ;
  88. ; pascal Ptr GetApplLimit(void)
  89. ;
  90.     IF ¬ GENERATINGCFM THEN
  91.         Macro
  92.         _GetApplLimit        &dest=(sp)
  93.         move.l               $0130,&dest
  94.         EndM
  95.     ELSE
  96.         IMPORT_CFM_FUNCTION    GetApplLimit
  97.     ENDIF
  98.  
  99. ;
  100. ; pascal THz SystemZone(void)
  101. ;
  102.     IF ¬ GENERATINGCFM THEN
  103.         Macro
  104.         _SystemZone          &dest=(sp)
  105.         move.l               $02A6,&dest
  106.         EndM
  107.     ELSE
  108.         IMPORT_CFM_FUNCTION    SystemZone
  109.     ENDIF
  110.  
  111. ;
  112. ; pascal THz ApplicationZone(void)
  113. ;
  114.     IF ¬ GENERATINGCFM THEN
  115.         Macro
  116.         _ApplicationZone     &dest=(sp)
  117.         move.l               $02AA,&dest
  118.         EndM
  119.     ELSE
  120.         IMPORT_CFM_FUNCTION    ApplicationZone
  121.     ENDIF
  122.  
  123. ;
  124. ; pascal Handle GZSaveHnd(void)
  125. ;
  126.     IF ¬ GENERATINGCFM THEN
  127.         Macro
  128.         _GZSaveHnd           &dest=(sp)
  129.         move.l               $0328,&dest
  130.         EndM
  131.     ELSE
  132.         IMPORT_CFM_FUNCTION    GZSaveHnd
  133.     ENDIF
  134.  
  135. ;
  136. ; pascal Ptr TopMem(void)
  137. ;
  138.     IF ¬ GENERATINGCFM THEN
  139.         Macro
  140.         _TopMem              &dest=(sp)
  141.         move.l               $0108,&dest
  142.         EndM
  143.     ELSE
  144.         IMPORT_CFM_FUNCTION    TopMem
  145.     ENDIF
  146.  
  147. ;
  148. ; pascal OSErr MemError(void)
  149. ;
  150.     IF ¬ GENERATINGCFM THEN
  151.         Macro
  152.         _MemError            &dest=(sp)
  153.         move.w               $0220,&dest
  154.         EndM
  155.     ELSE
  156.         IMPORT_CFM_FUNCTION    MemError
  157.     ENDIF
  158.  
  159. ;
  160. ; pascal THz GetZone(void)
  161. ;
  162.     IF ¬ GENERATINGCFM THEN
  163.         ; returns: 
  164.         ;     THz               <= A0
  165.         _GetZone:    OPWORD    $A11A
  166.     ELSE
  167.         IMPORT_CFM_FUNCTION    GetZone
  168.     ENDIF
  169.  
  170. ;
  171. ; pascal Handle NewHandle(Size byteCount)
  172. ;
  173.     IF ¬ GENERATINGCFM THEN
  174.         ; parameters: 
  175.         ;     byteCount         => D0
  176.         ; returns: 
  177.         ;     Handle            <= A0
  178.         _NewHandle:    OPWORD    $A122
  179.     ELSE
  180.         IMPORT_CFM_FUNCTION    NewHandle
  181.     ENDIF
  182.  
  183. ;
  184. ; pascal Handle NewHandleSys(Size byteCount)
  185. ;
  186.     IF ¬ GENERATINGCFM THEN
  187.         ; parameters: 
  188.         ;     byteCount         => D0
  189.         ; returns: 
  190.         ;     Handle            <= A0
  191.         _NewHandleSys:    OPWORD    $A522
  192.     ELSE
  193.         IMPORT_CFM_FUNCTION    NewHandleSys
  194.     ENDIF
  195.  
  196. ;
  197. ; pascal Handle NewHandleClear(Size byteCount)
  198. ;
  199.     IF ¬ GENERATINGCFM THEN
  200.         ; parameters: 
  201.         ;     byteCount         => D0
  202.         ; returns: 
  203.         ;     Handle            <= A0
  204.         _NewHandleClear:    OPWORD    $A322
  205.     ELSE
  206.         IMPORT_CFM_FUNCTION    NewHandleClear
  207.     ENDIF
  208.  
  209. ;
  210. ; pascal Handle NewHandleSysClear(Size byteCount)
  211. ;
  212.     IF ¬ GENERATINGCFM THEN
  213.         ; parameters: 
  214.         ;     byteCount         => D0
  215.         ; returns: 
  216.         ;     Handle            <= A0
  217.         _NewHandleSysClear:    OPWORD    $A722
  218.     ELSE
  219.         IMPORT_CFM_FUNCTION    NewHandleSysClear
  220.     ENDIF
  221.  
  222. ;
  223. ; pascal THz HandleZone(Handle h)
  224. ;
  225.     IF ¬ GENERATINGCFM THEN
  226.         ; parameters: 
  227.         ;     h                 => A0
  228.         ; returns: 
  229.         ;     THz               <= A0
  230.         _HandleZone:    OPWORD    $A126
  231.     ELSE
  232.         IMPORT_CFM_FUNCTION    HandleZone
  233.     ENDIF
  234.  
  235. ;
  236. ; pascal Handle RecoverHandle(Ptr p)
  237. ;
  238.     IF ¬ GENERATINGCFM THEN
  239.         ; parameters: 
  240.         ;     p                 => A0
  241.         ; returns: 
  242.         ;     Handle            <= A0
  243.         _RecoverHandle:    OPWORD    $A128
  244.     ELSE
  245.         IMPORT_CFM_FUNCTION    RecoverHandle
  246.     ENDIF
  247.  
  248. ;
  249. ; pascal Handle RecoverHandleSys(Ptr p)
  250. ;
  251.     IF ¬ GENERATINGCFM THEN
  252.         ; parameters: 
  253.         ;     p                 => A0
  254.         ; returns: 
  255.         ;     Handle            <= A0
  256.         _RecoverHandleSys:    OPWORD    $A528
  257.     ELSE
  258.         IMPORT_CFM_FUNCTION    RecoverHandleSys
  259.     ENDIF
  260.  
  261. ;
  262. ; pascal Ptr NewPtr(Size byteCount)
  263. ;
  264.     IF ¬ GENERATINGCFM THEN
  265.         ; parameters: 
  266.         ;     byteCount         => D0
  267.         ; returns: 
  268.         ;     Ptr               <= A0
  269.         _NewPtr:    OPWORD    $A11E
  270.     ELSE
  271.         IMPORT_CFM_FUNCTION    NewPtr
  272.     ENDIF
  273.  
  274. ;
  275. ; pascal Ptr NewPtrSys(Size byteCount)
  276. ;
  277.     IF ¬ GENERATINGCFM THEN
  278.         ; parameters: 
  279.         ;     byteCount         => D0
  280.         ; returns: 
  281.         ;     Ptr               <= A0
  282.         _NewPtrSys:    OPWORD    $A51E
  283.     ELSE
  284.         IMPORT_CFM_FUNCTION    NewPtrSys
  285.     ENDIF
  286.  
  287. ;
  288. ; pascal Ptr NewPtrClear(Size byteCount)
  289. ;
  290.     IF ¬ GENERATINGCFM THEN
  291.         ; parameters: 
  292.         ;     byteCount         => D0
  293.         ; returns: 
  294.         ;     Ptr               <= A0
  295.         _NewPtrClear:    OPWORD    $A31E
  296.     ELSE
  297.         IMPORT_CFM_FUNCTION    NewPtrClear
  298.     ENDIF
  299.  
  300. ;
  301. ; pascal Ptr NewPtrSysClear(Size byteCount)
  302. ;
  303.     IF ¬ GENERATINGCFM THEN
  304.         ; parameters: 
  305.         ;     byteCount         => D0
  306.         ; returns: 
  307.         ;     Ptr               <= A0
  308.         _NewPtrSysClear:    OPWORD    $A71E
  309.     ELSE
  310.         IMPORT_CFM_FUNCTION    NewPtrSysClear
  311.     ENDIF
  312.  
  313. ;
  314. ; pascal THz PtrZone(Ptr p)
  315. ;
  316.     IF ¬ GENERATINGCFM THEN
  317.         ; parameters: 
  318.         ;     p                 => A0
  319.         ; returns: 
  320.         ;     THz               <= A0
  321.         _PtrZone:    OPWORD    $A148
  322.     ELSE
  323.         IMPORT_CFM_FUNCTION    PtrZone
  324.     ENDIF
  325.  
  326. ;
  327. ; pascal long MaxBlock(void)
  328. ;
  329.     IF ¬ GENERATINGCFM THEN
  330.         ; returns: 
  331.         ;     long              <= D0
  332.         _MaxBlock:    OPWORD    $A061
  333.     ELSE
  334.         IMPORT_CFM_FUNCTION    MaxBlock
  335.     ENDIF
  336.  
  337. ;
  338. ; pascal long MaxBlockSys(void)
  339. ;
  340.     IF ¬ GENERATINGCFM THEN
  341.         ; returns: 
  342.         ;     long              <= D0
  343.         _MaxBlockSys:    OPWORD    $A461
  344.     ELSE
  345.         IMPORT_CFM_FUNCTION    MaxBlockSys
  346.     ENDIF
  347.  
  348. ;
  349. ; pascal long StackSpace(void)
  350. ;
  351.     IF ¬ GENERATINGCFM THEN
  352.         ; returns: 
  353.         ;     long              <= D0
  354.         _StackSpace:    OPWORD    $A065
  355.     ELSE
  356.         IMPORT_CFM_FUNCTION    StackSpace
  357.     ENDIF
  358.  
  359. ;
  360. ; pascal Handle NewEmptyHandle(void)
  361. ;
  362.     IF ¬ GENERATINGCFM THEN
  363.         ; returns: 
  364.         ;     Handle            <= A0
  365.         _NewEmptyHandle:    OPWORD    $A166
  366.     ELSE
  367.         IMPORT_CFM_FUNCTION    NewEmptyHandle
  368.     ENDIF
  369.  
  370. ;
  371. ; pascal Handle NewEmptyHandleSys(void)
  372. ;
  373.     IF ¬ GENERATINGCFM THEN
  374.         ; returns: 
  375.         ;     Handle            <= A0
  376.         _NewEmptyHandleSys:    OPWORD    $A566
  377.     ELSE
  378.         IMPORT_CFM_FUNCTION    NewEmptyHandleSys
  379.     ENDIF
  380.  
  381. ;
  382. ; pascal void HLock(Handle h)
  383. ;
  384.     IF ¬ GENERATINGCFM THEN
  385.         ; parameters: 
  386.         ;     h                 => A0
  387.         _HLock:    OPWORD    $A029
  388.     ELSE
  389.         IMPORT_CFM_FUNCTION    HLock
  390.     ENDIF
  391.  
  392. ;
  393. ; pascal void HUnlock(Handle h)
  394. ;
  395.     IF ¬ GENERATINGCFM THEN
  396.         ; parameters: 
  397.         ;     h                 => A0
  398.         _HUnlock:    OPWORD    $A02A
  399.     ELSE
  400.         IMPORT_CFM_FUNCTION    HUnlock
  401.     ENDIF
  402.  
  403. ;
  404. ; pascal void HPurge(Handle h)
  405. ;
  406.     IF ¬ GENERATINGCFM THEN
  407.         ; parameters: 
  408.         ;     h                 => A0
  409.         _HPurge:    OPWORD    $A049
  410.     ELSE
  411.         IMPORT_CFM_FUNCTION    HPurge
  412.     ENDIF
  413.  
  414. ;
  415. ; pascal void HNoPurge(Handle h)
  416. ;
  417.     IF ¬ GENERATINGCFM THEN
  418.         ; parameters: 
  419.         ;     h                 => A0
  420.         _HNoPurge:    OPWORD    $A04A
  421.     ELSE
  422.         IMPORT_CFM_FUNCTION    HNoPurge
  423.     ENDIF
  424.  
  425. ;
  426. ; pascal void HLockHi(Handle h)
  427. ;
  428.     IF ¬ GENERATINGCFM THEN
  429.         ; parameters: 
  430.         ;     h                 => A0
  431.         Macro
  432.         _HLockHi
  433.             dc.w     $A064
  434.             dc.w     $A029
  435.         EndM
  436.     ELSE
  437.         IMPORT_CFM_FUNCTION    HLockHi
  438.     ENDIF
  439.  
  440. ;
  441. ; pascal Handle TempNewHandle(Size logicalSize, OSErr *resultCode)
  442. ;
  443.     IF ¬ GENERATINGCFM THEN
  444.         Macro
  445.         _TempNewHandle
  446.             move.w    #$001D,-(sp)
  447.             dc.w     $A88F
  448.         EndM
  449.     ELSE
  450.         IMPORT_CFM_FUNCTION    TempNewHandle
  451.     ENDIF
  452.  
  453. ;
  454. ; pascal Size TempMaxMem(Size *grow)
  455. ;
  456.     IF ¬ GENERATINGCFM THEN
  457.         Macro
  458.         _TempMaxMem
  459.             move.w    #$0015,-(sp)
  460.             dc.w     $A88F
  461.         EndM
  462.     ELSE
  463.         IMPORT_CFM_FUNCTION    TempMaxMem
  464.     ENDIF
  465.  
  466. ;
  467. ; pascal long TempFreeMem(void)
  468. ;
  469.     IF ¬ GENERATINGCFM THEN
  470.         Macro
  471.         _TempFreeMem
  472.             move.w    #$0018,-(sp)
  473.             dc.w     $A88F
  474.         EndM
  475.     ELSE
  476.         IMPORT_CFM_FUNCTION    TempFreeMem
  477.     ENDIF
  478.  
  479. ;  Temporary Memory routines renamed, but obsolete, in System 7.0 and later.  
  480. ;
  481. ; pascal void TempHLock(Handle h, OSErr *resultCode)
  482. ;
  483.     IF ¬ GENERATINGCFM THEN
  484.         Macro
  485.         _TempHLock
  486.             move.w    #$001E,-(sp)
  487.             dc.w     $A88F
  488.         EndM
  489.     ELSE
  490.         IMPORT_CFM_FUNCTION    TempHLock
  491.     ENDIF
  492.  
  493. ;
  494. ; pascal void TempHUnlock(Handle h, OSErr *resultCode)
  495. ;
  496.     IF ¬ GENERATINGCFM THEN
  497.         Macro
  498.         _TempHUnlock
  499.             move.w    #$001F,-(sp)
  500.             dc.w     $A88F
  501.         EndM
  502.     ELSE
  503.         IMPORT_CFM_FUNCTION    TempHUnlock
  504.     ENDIF
  505.  
  506. ;
  507. ; pascal void TempDisposeHandle(Handle h, OSErr *resultCode)
  508. ;
  509.     IF ¬ GENERATINGCFM THEN
  510.         Macro
  511.         _TempDisposeHandle
  512.             move.w    #$0020,-(sp)
  513.             dc.w     $A88F
  514.         EndM
  515.     ELSE
  516.         IMPORT_CFM_FUNCTION    TempDisposeHandle
  517.     ENDIF
  518.  
  519. ;
  520. ; pascal Ptr TempTopMem(void)
  521. ;
  522.     IF ¬ GENERATINGCFM THEN
  523.         Macro
  524.         _TempTopMem
  525.             move.w    #$0016,-(sp)
  526.             dc.w     $A88F
  527.         EndM
  528.     ELSE
  529.         IMPORT_CFM_FUNCTION    TempTopMem
  530.     ENDIF
  531.  
  532. ;
  533. ; pascal void InitApplZone(void)
  534. ;
  535.     IF ¬ GENERATINGCFM THEN
  536.         _InitApplZone:    OPWORD    $A02C
  537.     ELSE
  538.         IMPORT_CFM_FUNCTION    InitApplZone
  539.     ENDIF
  540.  
  541. ;
  542. ; pascal void InitZone(GrowZoneUPP pgrowZone, short cmoreMasters, void *limitPtr, void *startPtr)
  543. ;
  544.     IF ¬ GENERATINGCFM THEN
  545.         _InitZone:    OPWORD    $A019
  546.     ELSE
  547.         IMPORT_CFM_FUNCTION    InitZone
  548.     ENDIF
  549.  
  550. ;
  551. ; pascal void SetZone(THz hz)
  552. ;
  553.     IF ¬ GENERATINGCFM THEN
  554.         ; parameters: 
  555.         ;     hz                => A0
  556.         _SetZone:    OPWORD    $A01B
  557.     ELSE
  558.         IMPORT_CFM_FUNCTION    SetZone
  559.     ENDIF
  560.  
  561. ;
  562. ; pascal Size CompactMem(Size cbNeeded)
  563. ;
  564.     IF ¬ GENERATINGCFM THEN
  565.         ; parameters: 
  566.         ;     cbNeeded          => D0
  567.         ; returns: 
  568.         ;     Size              <= D0
  569.         _CompactMem:    OPWORD    $A04C
  570.     ELSE
  571.         IMPORT_CFM_FUNCTION    CompactMem
  572.     ENDIF
  573.  
  574. ;
  575. ; pascal Size CompactMemSys(Size cbNeeded)
  576. ;
  577.     IF ¬ GENERATINGCFM THEN
  578.         ; parameters: 
  579.         ;     cbNeeded          => D0
  580.         ; returns: 
  581.         ;     Size              <= D0
  582.         _CompactMemSys:    OPWORD    $A44C
  583.     ELSE
  584.         IMPORT_CFM_FUNCTION    CompactMemSys
  585.     ENDIF
  586.  
  587. ;
  588. ; pascal void PurgeMem(Size cbNeeded)
  589. ;
  590.     IF ¬ GENERATINGCFM THEN
  591.         ; parameters: 
  592.         ;     cbNeeded          => D0
  593.         _PurgeMem:    OPWORD    $A04D
  594.     ELSE
  595.         IMPORT_CFM_FUNCTION    PurgeMem
  596.     ENDIF
  597.  
  598. ;
  599. ; pascal void PurgeMemSys(Size cbNeeded)
  600. ;
  601.     IF ¬ GENERATINGCFM THEN
  602.         ; parameters: 
  603.         ;     cbNeeded          => D0
  604.         _PurgeMemSys:    OPWORD    $A44D
  605.     ELSE
  606.         IMPORT_CFM_FUNCTION    PurgeMemSys
  607.     ENDIF
  608.  
  609. ;
  610. ; pascal long FreeMem(void)
  611. ;
  612.     IF ¬ GENERATINGCFM THEN
  613.         ; returns: 
  614.         ;     long              <= D0
  615.         _FreeMem:    OPWORD    $A01C
  616.     ELSE
  617.         IMPORT_CFM_FUNCTION    FreeMem
  618.     ENDIF
  619.  
  620. ;
  621. ; pascal long FreeMemSys(void)
  622. ;
  623.     IF ¬ GENERATINGCFM THEN
  624.         ; returns: 
  625.         ;     long              <= D0
  626.         _FreeMemSys:    OPWORD    $A41C
  627.     ELSE
  628.         IMPORT_CFM_FUNCTION    FreeMemSys
  629.     ENDIF
  630.  
  631. ;
  632. ; pascal void ReserveMem(Size cbNeeded)
  633. ;
  634.     IF ¬ GENERATINGCFM THEN
  635.         ; parameters: 
  636.         ;     cbNeeded          => D0
  637.         _ReserveMem:    OPWORD    $A040
  638.     ELSE
  639.         IMPORT_CFM_FUNCTION    ReserveMem
  640.     ENDIF
  641.  
  642. ;
  643. ; pascal void ReserveMemSys(Size cbNeeded)
  644. ;
  645.     IF ¬ GENERATINGCFM THEN
  646.         ; parameters: 
  647.         ;     cbNeeded          => D0
  648.         _ReserveMemSys:    OPWORD    $A440
  649.     ELSE
  650.         IMPORT_CFM_FUNCTION    ReserveMemSys
  651.     ENDIF
  652.  
  653. ;
  654. ; pascal Size MaxMem(Size *grow)
  655. ;
  656.     IF ¬ GENERATINGCFM THEN
  657.         ; parameters: 
  658.         ;     grow              => A1
  659.         ; returns: 
  660.         ;     Size              <= D0
  661.         Macro
  662.         _MaxMem
  663.             dc.w     $A11D
  664.             dc.w     $2288
  665.         EndM
  666.     ELSE
  667.         IMPORT_CFM_FUNCTION    MaxMem
  668.     ENDIF
  669.  
  670. ;
  671. ; pascal Size MaxMemSys(Size *grow)
  672. ;
  673.     IF ¬ GENERATINGCFM THEN
  674.         ; parameters: 
  675.         ;     grow              => A1
  676.         ; returns: 
  677.         ;     Size              <= D0
  678.         Macro
  679.         _MaxMemSys
  680.             dc.w     $A51D
  681.             dc.w     $2288
  682.         EndM
  683.     ELSE
  684.         IMPORT_CFM_FUNCTION    MaxMemSys
  685.     ENDIF
  686.  
  687. ;
  688. ; pascal void SetGrowZone(GrowZoneUPP growZone)
  689. ;
  690.     IF ¬ GENERATINGCFM THEN
  691.         ; parameters: 
  692.         ;     growZone          => A0
  693.         _SetGrowZone:    OPWORD    $A04B
  694.     ELSE
  695.         IMPORT_CFM_FUNCTION    SetGrowZone
  696.     ENDIF
  697.  
  698. ;
  699. ; pascal void SetApplLimit(void *zoneLimit)
  700. ;
  701.     IF ¬ GENERATINGCFM THEN
  702.         ; parameters: 
  703.         ;     zoneLimit         => A0
  704.         _SetApplLimit:    OPWORD    $A02D
  705.     ELSE
  706.         IMPORT_CFM_FUNCTION    SetApplLimit
  707.     ENDIF
  708.  
  709. ;
  710. ; pascal void MoveHHi(Handle h)
  711. ;
  712.     IF ¬ GENERATINGCFM THEN
  713.         ; parameters: 
  714.         ;     h                 => A0
  715.         _MoveHHi:    OPWORD    $A064
  716.     ELSE
  717.         IMPORT_CFM_FUNCTION    MoveHHi
  718.     ENDIF
  719.  
  720. ;
  721. ; pascal void DisposePtr(Ptr p)
  722. ;
  723.     IF ¬ GENERATINGCFM THEN
  724.         ; parameters: 
  725.         ;     p                 => A0
  726.         _DisposePtr:    OPWORD    $A01F
  727.     ELSE
  728.         IMPORT_CFM_FUNCTION    DisposePtr
  729.     ENDIF
  730.  
  731. ;
  732. ; pascal Size GetPtrSize(Ptr p)
  733. ;
  734.     IF ¬ GENERATINGCFM THEN
  735.         _GetPtrSize:    OPWORD    $A021
  736.     ELSE
  737.         IMPORT_CFM_FUNCTION    GetPtrSize
  738.     ENDIF
  739.  
  740. ;
  741. ; pascal void SetPtrSize(Ptr p, Size newSize)
  742. ;
  743.     IF ¬ GENERATINGCFM THEN
  744.         ; parameters: 
  745.         ;     p                 => A0
  746.         ;     newSize           => D0
  747.         _SetPtrSize:    OPWORD    $A020
  748.     ELSE
  749.         IMPORT_CFM_FUNCTION    SetPtrSize
  750.     ENDIF
  751.  
  752. ;
  753. ; pascal void DisposeHandle(Handle h)
  754. ;
  755.     IF ¬ GENERATINGCFM THEN
  756.         ; parameters: 
  757.         ;     h                 => A0
  758.         _DisposeHandle:    OPWORD    $A023
  759.     ELSE
  760.         IMPORT_CFM_FUNCTION    DisposeHandle
  761.     ENDIF
  762.  
  763. ;
  764. ; pascal void SetHandleSize(Handle h, Size newSize)
  765. ;
  766.     IF ¬ GENERATINGCFM THEN
  767.         ; parameters: 
  768.         ;     h                 => A0
  769.         ;     newSize           => D0
  770.         _SetHandleSize:    OPWORD    $A024
  771.     ELSE
  772.         IMPORT_CFM_FUNCTION    SetHandleSize
  773.     ENDIF
  774.  
  775. ;
  776. ; pascal Size GetHandleSize(Handle h)
  777. ;
  778.     IF ¬ GENERATINGCFM THEN
  779.         _GetHandleSize:    OPWORD    $A025
  780.     ELSE
  781.         IMPORT_CFM_FUNCTION    GetHandleSize
  782.     ENDIF
  783.  
  784. ;
  785. ; pascal Size InlineGetHandleSize(Handle h)
  786. ;
  787.     IF ¬ GENERATINGCFM THEN
  788.         ; parameters: 
  789.         ;     h                 => A0
  790.         ; returns: 
  791.         ;     Size              <= D0
  792.         _InlineGetHandleSize:    OPWORD    $A025
  793.     ELSE
  794.         IMPORT_CFM_FUNCTION    InlineGetHandleSize
  795.     ENDIF
  796.  
  797. ;
  798. ; pascal void ReallocateHandle(Handle h, Size byteCount)
  799. ;
  800.     IF ¬ GENERATINGCFM THEN
  801.         ; parameters: 
  802.         ;     h                 => A0
  803.         ;     byteCount         => D0
  804.         _ReallocateHandle:    OPWORD    $A027
  805.     ELSE
  806.         IMPORT_CFM_FUNCTION    ReallocateHandle
  807.     ENDIF
  808.  
  809. ;
  810. ; pascal void EmptyHandle(Handle h)
  811. ;
  812.     IF ¬ GENERATINGCFM THEN
  813.         ; parameters: 
  814.         ;     h                 => A0
  815.         _EmptyHandle:    OPWORD    $A02B
  816.     ELSE
  817.         IMPORT_CFM_FUNCTION    EmptyHandle
  818.     ENDIF
  819.  
  820. ;
  821. ; pascal void HSetRBit(Handle h)
  822. ;
  823.     IF ¬ GENERATINGCFM THEN
  824.         ; parameters: 
  825.         ;     h                 => A0
  826.         _HSetRBit:    OPWORD    $A067
  827.     ELSE
  828.         IMPORT_CFM_FUNCTION    HSetRBit
  829.     ENDIF
  830.  
  831. ;
  832. ; pascal void HClrRBit(Handle h)
  833. ;
  834.     IF ¬ GENERATINGCFM THEN
  835.         ; parameters: 
  836.         ;     h                 => A0
  837.         _HClrRBit:    OPWORD    $A068
  838.     ELSE
  839.         IMPORT_CFM_FUNCTION    HClrRBit
  840.     ENDIF
  841.  
  842. ;
  843. ; pascal void MoreMasters(void)
  844. ;
  845.     IF ¬ GENERATINGCFM THEN
  846.         _MoreMasters:    OPWORD    $A036
  847.     ELSE
  848.         IMPORT_CFM_FUNCTION    MoreMasters
  849.     ENDIF
  850.  
  851. ;
  852. ; pascal void BlockMove(const void *srcPtr, void *destPtr, Size byteCount)
  853. ;
  854.     IF ¬ GENERATINGCFM THEN
  855.         ; parameters: 
  856.         ;     srcPtr            => A0
  857.         ;     destPtr           => A1
  858.         ;     byteCount         => D0
  859.         _BlockMove:    OPWORD    $A02E
  860.     ELSE
  861.         IMPORT_CFM_FUNCTION    BlockMove
  862.     ENDIF
  863.  
  864. ;
  865. ; pascal void BlockMoveData(const void *srcPtr, void *destPtr, Size byteCount)
  866. ;
  867.     IF ¬ GENERATINGCFM THEN
  868.         ; parameters: 
  869.         ;     srcPtr            => A0
  870.         ;     destPtr           => A1
  871.         ;     byteCount         => D0
  872.         _BlockMoveData:    OPWORD    $A22E
  873.     ELSE
  874.         IMPORT_CFM_FUNCTION    BlockMoveData
  875.     ENDIF
  876.  
  877. ;
  878. ; pascal void PurgeSpace(long *total, long *contig)
  879. ;
  880.     IF ¬ GENERATINGCFM THEN
  881.         _PurgeSpace:    OPWORD    $A162
  882.     ELSE
  883.         IMPORT_CFM_FUNCTION    PurgeSpace
  884.     ENDIF
  885.  
  886. ;
  887. ; pascal SInt8 HGetState(Handle h)
  888. ;
  889.     IF ¬ GENERATINGCFM THEN
  890.         ; parameters: 
  891.         ;     h                 => A0
  892.         ; returns: 
  893.         ;     SInt8             <= D0
  894.         _HGetState:    OPWORD    $A069
  895.     ELSE
  896.         IMPORT_CFM_FUNCTION    HGetState
  897.     ENDIF
  898.  
  899. ;
  900. ; pascal void HSetState(Handle h, SInt8 flags)
  901. ;
  902.     IF ¬ GENERATINGCFM THEN
  903.         ; parameters: 
  904.         ;     h                 => A0
  905.         ;     flags             => D0
  906.         _HSetState:    OPWORD    $A06A
  907.     ELSE
  908.         IMPORT_CFM_FUNCTION    HSetState
  909.     ENDIF
  910.  
  911. ;
  912. ; pascal void SetApplBase(void *startPtr)
  913. ;
  914.     IF ¬ GENERATINGCFM THEN
  915.         ; parameters: 
  916.         ;     startPtr          => A0
  917.         _SetApplBase:    OPWORD    $A057
  918.     ELSE
  919.         IMPORT_CFM_FUNCTION    SetApplBase
  920.     ENDIF
  921.  
  922. ;
  923. ; pascal void MaxApplZone(void)
  924. ;
  925.     IF ¬ GENERATINGCFM THEN
  926.         _MaxApplZone:    OPWORD    $A063
  927.     ELSE
  928.         IMPORT_CFM_FUNCTION    MaxApplZone
  929.     ENDIF
  930.  
  931. ;
  932. ; pascal OSErr HoldMemory(void *address, unsigned long count)
  933. ;
  934.     IF ¬ GENERATINGCFM THEN
  935.         ; parameters: 
  936.         ;     address           => A0
  937.         ;     count             => A1
  938.         ; returns: 
  939.         ;     OSErr             <= D0
  940.         Macro
  941.         _HoldMemory
  942.             moveq    #0,d0
  943.             dc.w     $A05C
  944.         EndM
  945.     ELSE
  946.         IMPORT_CFM_FUNCTION    HoldMemory
  947.     ENDIF
  948.  
  949. ;
  950. ; pascal OSErr UnholdMemory(void *address, unsigned long count)
  951. ;
  952.     IF ¬ GENERATINGCFM THEN
  953.         ; parameters: 
  954.         ;     address           => A0
  955.         ;     count             => A1
  956.         ; returns: 
  957.         ;     OSErr             <= D0
  958.         Macro
  959.         _UnholdMemory
  960.             moveq    #1,d0
  961.             dc.w     $A05C
  962.         EndM
  963.     ELSE
  964.         IMPORT_CFM_FUNCTION    UnholdMemory
  965.     ENDIF
  966.  
  967. ;
  968. ; pascal OSErr LockMemory(void *address, unsigned long count)
  969. ;
  970.     IF ¬ GENERATINGCFM THEN
  971.         ; parameters: 
  972.         ;     address           => A0
  973.         ;     count             => A1
  974.         ; returns: 
  975.         ;     OSErr             <= D0
  976.         Macro
  977.         _LockMemory
  978.             moveq    #2,d0
  979.             dc.w     $A05C
  980.         EndM
  981.     ELSE
  982.         IMPORT_CFM_FUNCTION    LockMemory
  983.     ENDIF
  984.  
  985. ;
  986. ; pascal OSErr LockMemoryContiguous(void *address, unsigned long count)
  987. ;
  988.     IF ¬ GENERATINGCFM THEN
  989.         ; parameters: 
  990.         ;     address           => A0
  991.         ;     count             => A1
  992.         ; returns: 
  993.         ;     OSErr             <= D0
  994.         Macro
  995.         _LockMemoryContiguous
  996.             moveq    #4,d0
  997.             dc.w     $A05C
  998.         EndM
  999.     ELSE
  1000.         IMPORT_CFM_FUNCTION    LockMemoryContiguous
  1001.     ENDIF
  1002.  
  1003. ;
  1004. ; pascal OSErr UnlockMemory(void *address, unsigned long count)
  1005. ;
  1006.     IF ¬ GENERATINGCFM THEN
  1007.         ; parameters: 
  1008.         ;     address           => A0
  1009.         ;     count             => A1
  1010.         ; returns: 
  1011.         ;     OSErr             <= D0
  1012.         Macro
  1013.         _UnlockMemory
  1014.             moveq    #3,d0
  1015.             dc.w     $A05C
  1016.         EndM
  1017.     ELSE
  1018.         IMPORT_CFM_FUNCTION    UnlockMemory
  1019.     ENDIF
  1020.  
  1021. ;
  1022. ; pascal OSErr GetPhysical(LogicalToPhysicalTable *addresses, unsigned long *physicalEntryCount)
  1023. ;
  1024.     IF ¬ GENERATINGCFM THEN
  1025.         Macro
  1026.         _GetPhysical
  1027.             moveq    #5,d0
  1028.             dc.w     $A05C
  1029.         EndM
  1030.     ELSE
  1031.         IMPORT_CFM_FUNCTION    GetPhysical
  1032.     ENDIF
  1033.  
  1034. ;
  1035. ; pascal OSErr DeferUserFn(UserFnUPP userFunction, void *argument)
  1036. ;
  1037.     IF ¬ GENERATINGCFM THEN
  1038.         ; parameters: 
  1039.         ;     userFunction      => A0
  1040.         ;     argument          => D0
  1041.         ; returns: 
  1042.         ;     OSErr             <= D0
  1043.         _DeferUserFn:    OPWORD    $A08F
  1044.     ELSE
  1045.         IMPORT_CFM_FUNCTION    DeferUserFn
  1046.     ENDIF
  1047.  
  1048. ;
  1049. ; pascal long DebuggerGetMax(void)
  1050. ;
  1051.     IF ¬ GENERATINGCFM THEN
  1052.         ; returns: 
  1053.         ;     long              <= D0
  1054.         Macro
  1055.         _DebuggerGetMax
  1056.             moveq    #0,d0
  1057.             dc.w     $A08D
  1058.         EndM
  1059.     ELSE
  1060.         IMPORT_CFM_FUNCTION    DebuggerGetMax
  1061.     ENDIF
  1062.  
  1063. ;
  1064. ; pascal void DebuggerEnter(void)
  1065. ;
  1066.     IF ¬ GENERATINGCFM THEN
  1067.         Macro
  1068.         _DebuggerEnter
  1069.             moveq    #1,d0
  1070.             dc.w     $A08D
  1071.         EndM
  1072.     ELSE
  1073.         IMPORT_CFM_FUNCTION    DebuggerEnter
  1074.     ENDIF
  1075.  
  1076. ;
  1077. ; pascal void DebuggerExit(void)
  1078. ;
  1079.     IF ¬ GENERATINGCFM THEN
  1080.         Macro
  1081.         _DebuggerExit
  1082.             moveq    #2,d0
  1083.             dc.w     $A08D
  1084.         EndM
  1085.     ELSE
  1086.         IMPORT_CFM_FUNCTION    DebuggerExit
  1087.     ENDIF
  1088.  
  1089. ;
  1090. ; pascal void DebuggerPoll(void)
  1091. ;
  1092.     IF ¬ GENERATINGCFM THEN
  1093.         Macro
  1094.         _DebuggerPoll
  1095.             moveq    #3,d0
  1096.             dc.w     $A08D
  1097.         EndM
  1098.     ELSE
  1099.         IMPORT_CFM_FUNCTION    DebuggerPoll
  1100.     ENDIF
  1101.  
  1102. ;
  1103. ; pascal PageState GetPageState(const void *address)
  1104. ;
  1105.     IF ¬ GENERATINGCFM THEN
  1106.         ; parameters: 
  1107.         ;     address           => A0
  1108.         ; returns: 
  1109.         ;     PageState         <= D0
  1110.         Macro
  1111.         _GetPageState
  1112.             moveq    #4,d0
  1113.             dc.w     $A08D
  1114.         EndM
  1115.     ELSE
  1116.         IMPORT_CFM_FUNCTION    GetPageState
  1117.     ENDIF
  1118.  
  1119. ;
  1120. ; pascal Boolean PageFaultFatal(void)
  1121. ;
  1122.     IF ¬ GENERATINGCFM THEN
  1123.         ; returns: 
  1124.         ;     Boolean           <= D0
  1125.         Macro
  1126.         _PageFaultFatal
  1127.             moveq    #5,d0
  1128.             dc.w     $A08D
  1129.         EndM
  1130.     ELSE
  1131.         IMPORT_CFM_FUNCTION    PageFaultFatal
  1132.     ENDIF
  1133.  
  1134. ;
  1135. ; pascal OSErr DebuggerLockMemory(void *address, unsigned long count)
  1136. ;
  1137.     IF ¬ GENERATINGCFM THEN
  1138.         ; parameters: 
  1139.         ;     address           => A0
  1140.         ;     count             => A1
  1141.         ; returns: 
  1142.         ;     OSErr             <= D0
  1143.         Macro
  1144.         _DebuggerLockMemory
  1145.             moveq    #6,d0
  1146.             dc.w     $A08D
  1147.         EndM
  1148.     ELSE
  1149.         IMPORT_CFM_FUNCTION    DebuggerLockMemory
  1150.     ENDIF
  1151.  
  1152. ;
  1153. ; pascal OSErr DebuggerUnlockMemory(void *address, unsigned long count)
  1154. ;
  1155.     IF ¬ GENERATINGCFM THEN
  1156.         ; parameters: 
  1157.         ;     address           => A0
  1158.         ;     count             => A1
  1159.         ; returns: 
  1160.         ;     OSErr             <= D0
  1161.         Macro
  1162.         _DebuggerUnlockMemory
  1163.             moveq    #7,d0
  1164.             dc.w     $A08D
  1165.         EndM
  1166.     ELSE
  1167.         IMPORT_CFM_FUNCTION    DebuggerUnlockMemory
  1168.     ENDIF
  1169.  
  1170. ;
  1171. ; pascal StatusRegisterContents EnterSupervisorMode(void)
  1172. ;
  1173.     IF ¬ GENERATINGCFM THEN
  1174.         ; returns: 
  1175.         ;     StatusRegisterContents    <= D0
  1176.         Macro
  1177.         _EnterSupervisorMode
  1178.             moveq    #8,d0
  1179.             dc.w     $A08D
  1180.         EndM
  1181.     ELSE
  1182.         IMPORT_CFM_FUNCTION    EnterSupervisorMode
  1183.     ENDIF
  1184.  
  1185. ; StripAddress and Translate24To32 macro to nothing on PowerPC
  1186. ;   StripAddress is implemented as a trap in System 6 or later 
  1187.     IF SystemSixOrLater  THEN
  1188. ;
  1189. ; pascal Ptr StripAddress(void *theAddress)
  1190. ;
  1191.     IF ¬ GENERATINGCFM THEN
  1192.         ; parameters: 
  1193.         ;     theAddress        => D0
  1194.         ; returns: 
  1195.         ;     Ptr               <= D0
  1196.         _StripAddress:    OPWORD    $A055
  1197.     ELSE
  1198.         IMPORT_CFM_FUNCTION    StripAddress
  1199.     ENDIF
  1200.  
  1201.     ELSE
  1202. ;
  1203. ; pascal Ptr StripAddress(void *theAddress)
  1204. ;
  1205.     IF GENERATINGCFM THEN
  1206.         IMPORT_CFM_FUNCTION    StripAddress
  1207.     ENDIF
  1208.  
  1209.     ENDIF
  1210. ;
  1211. ; pascal Ptr Translate24To32(void *addr24)
  1212. ;
  1213.     IF ¬ GENERATINGCFM THEN
  1214.         ; parameters: 
  1215.         ;     addr24            => D0
  1216.         ; returns: 
  1217.         ;     Ptr               <= D0
  1218.         _Translate24To32:    OPWORD    $A091
  1219.     ELSE
  1220.         IMPORT_CFM_FUNCTION    Translate24To32
  1221.     ENDIF
  1222.  
  1223. ;
  1224. ; pascal OSErr HandToHand(Handle *theHndl)
  1225. ;
  1226.     IF GENERATINGCFM THEN
  1227.         IMPORT_CFM_FUNCTION    HandToHand
  1228.     ENDIF
  1229.  
  1230. ;
  1231. ; pascal OSErr PtrToXHand(const void *srcPtr, Handle dstHndl, long size)
  1232. ;
  1233.     IF ¬ GENERATINGCFM THEN
  1234.         ; parameters: 
  1235.         ;     srcPtr            => A0
  1236.         ;     dstHndl           => A1
  1237.         ;     size              => D0
  1238.         ; returns: 
  1239.         ;     OSErr             <= D0
  1240.         _PtrToXHand:    OPWORD    $A9E2
  1241.     ELSE
  1242.         IMPORT_CFM_FUNCTION    PtrToXHand
  1243.     ENDIF
  1244.  
  1245. ;
  1246. ; pascal OSErr PtrToHand(const void *srcPtr, Handle *dstHndl, long size)
  1247. ;
  1248.     IF GENERATINGCFM THEN
  1249.         IMPORT_CFM_FUNCTION    PtrToHand
  1250.     ENDIF
  1251.  
  1252. ;
  1253. ; pascal OSErr HandAndHand(Handle hand1, Handle hand2)
  1254. ;
  1255.     IF ¬ GENERATINGCFM THEN
  1256.         ; parameters: 
  1257.         ;     hand1             => A0
  1258.         ;     hand2             => A1
  1259.         ; returns: 
  1260.         ;     OSErr             <= D0
  1261.         _HandAndHand:    OPWORD    $A9E4
  1262.     ELSE
  1263.         IMPORT_CFM_FUNCTION    HandAndHand
  1264.     ENDIF
  1265.  
  1266. ;
  1267. ; pascal OSErr PtrAndHand(const void *ptr1, Handle hand2, long size)
  1268. ;
  1269.     IF ¬ GENERATINGCFM THEN
  1270.         ; parameters: 
  1271.         ;     ptr1              => A0
  1272.         ;     hand2             => A1
  1273.         ;     size              => D0
  1274.         ; returns: 
  1275.         ;     OSErr             <= D0
  1276.         _PtrAndHand:    OPWORD    $A9EF
  1277.     ELSE
  1278.         IMPORT_CFM_FUNCTION    PtrAndHand
  1279.     ENDIF
  1280.  
  1281.     IF OLDROUTINENAMES  THEN
  1282.     ENDIF
  1283.     ENDIF ; __MEMORY__
  1284.